package Analizador;

import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Lexico {

    final int TOKREC = 7;
    final int MAXTOKENS = 500;
    private String[] _lexemas,_tsLexemas;
    private String[] _tokens,_tsTokens;
    private String[] _reservada,_tsReservada;
    private String _lexema,_tsLexema;
    private int _noTokens,_tsNoTokens;
    private int _i,_tsI;
    private int _iniToken,_tsIniToken;
    private Automata oAFD;
    Archivo archivo = new Archivo();

    public Lexico() // constructor por defecto 
    {
        _lexemas = new String[MAXTOKENS];
        _tokens = new String[MAXTOKENS];
        _reservada = new String[MAXTOKENS];
        _tsLexemas = new String[MAXTOKENS];
        _tsTokens = new String[MAXTOKENS];
        _tsReservada = new String[MAXTOKENS];
        oAFD = new Automata();
        _i = 0;
        _iniToken = 0;
        _noTokens = 0;
    }

    public void Inicia() {
        _i = 0;
        _iniToken = 0;
        _noTokens = 0;
        _lexemas = new String[MAXTOKENS];
        _tokens = new String[MAXTOKENS];
        _reservada = new String[MAXTOKENS];
    }

    public void TSInicia() {
        _tsI = 0;
        _tsIniToken = 0;
        _tsNoTokens = 0;
        _tsLexemas = new String[MAXTOKENS];
        _tsTokens = new String[MAXTOKENS];
        _tsReservada = new String[MAXTOKENS];
    }

    public void Analiza(String texto) {
        Boolean recAuto;
        int noAuto;
        String nombreArch = "Salida.txt";
        
        try {
            archivo.Eliminar(nombreArch);
        } catch (Exception ex) {
            Logger.getLogger(Lexico.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        while (_i < texto.length()) {
            recAuto = false;
            noAuto = 0;
            for (; noAuto < TOKREC && !recAuto;) {
                if (oAFD.Reconoce(texto, this, noAuto)) {
                    recAuto = true;
                } else {
                    noAuto++;
                }
            }
            if (recAuto) {
                _lexema = texto.substring(_iniToken, _i);
                int cant = 0;
                
                for (int i = 0; i < _tsLexemas.length; i++){
                    if(_tsLexemas[i] != null)
                        cant++;
                }
                
                for (int i = 0; i < cant; i++){
                    if(_tsLexemas[i].equals(_lexema)){
                        _tokens[_noTokens] = _tsTokens[i];
                        _reservada[_noTokens] = _tsReservada[i];
                        noAuto = -1;
                    }
                }
                switch (noAuto) {
                    //--------------  Automata  delim-------------- 
                    case 0:
                        _tokens[_noTokens] = "espacio";
                        _reservada[_noTokens] = "No";
                        break;
                    //--------------  Automata  Id-------------- 
                    case 1:
                        _tokens[_noTokens] = "id";
                        _reservada[_noTokens] = "No";
                        break;
                    //--------------  Automata  OpAsig-------------- 
                    case 2:
                        _tokens[_noTokens] = "OpAsig";
                        _reservada[_noTokens] = "Si";
                        break;
                    //--------------  Automata  oparit-------------- 
                    case 3:
                        _tokens[_noTokens] = "OpArit";
                        _reservada[_noTokens] = "Si";
                        break;
                    //--------------  Automata  num-------------- 
                    case 4:
                        _tokens[_noTokens] = "numero";
                        _reservada[_noTokens] = "No";
                        break;
                    //--------------  Automata  sep-------------- 
                    case 5:
                        _tokens[_noTokens] = "separador";
                        _reservada[_noTokens] = "Si";
                        break;
                    //--------------  Automata  termInst-------------- 
                    case 6:
                        _tokens[_noTokens] = "terminar instancia";
                        _reservada[_noTokens] = "Si";
                        break;
                }
                _lexemas[_noTokens++] = _lexema;
            } else {
                _i++;
            }
            _iniToken = _i;
            
            if(_tokens[_noTokens-1].equals("espacio")){
                try {
                    archivo.generarArchivo(_lexemas[_noTokens-1],nombreArch);
                } catch (IOException ex) {
                    Logger.getLogger(Lexico.class.getName()).log(Level.SEVERE, null, ex);
                }
            }else{
                try {
                    archivo.generarArchivo(_tokens[_noTokens-1],nombreArch);
                } catch (IOException ex) {
                    Logger.getLogger(Lexico.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }

    } // fin del método Analiza() 
    
    public void cargaObjTablaSimbolos(String cadena[]){
        _tsTokens[_tsNoTokens] = cadena[0];
        _tsLexemas[_tsNoTokens] = cadena[1];
        _tsReservada[_tsNoTokens++] = cadena[2];
    }

    public int getI() {
        return _i;
    }

    public void setI(int valor) {
        _i = valor;
    }

    public int getIniToken() {
        return _iniToken;
    }

    public String[] Tokens() {
        return _tokens;
    }

    public String[] Lexemas() {
        return _lexemas;
    }

    public String[] Reservada() {
        return _reservada;
    }

    public int getIniTSToken() {
        return _iniToken;
    }

    public String[] TSTokens() {
        return _tsTokens;
    }

    public String[] TSLexemas() {
        return _tsLexemas;
    }

    public String[] TSReservada() {
        return _tsReservada;
    }
}  // fin de la clase Lexico 
//---------------------------- 

